#include "../Entetes/etat.h"

/*!
Ce constructeur permet de créer un état trivial.
Le champ final vaut zéro et etat_trans est vide.
\fn etat::etat()
\brief Constructeur par défaut.
*/
etat::etat()
{
	final = 0;
	etat_trans.clear();	
}

/*!
Ce constructeur permet de créer un état à partir d'un pointeur sur état et d'une transition.
Le champ final vaut zéro et etat_trans est initialisé grâce au paramètre tr.
\fn etat::etat(etat* ptr, transitions tr)
\param etat* ptr, transitions tr
\brief Constructeur.
*/
etat::etat(etat* ptr, transitions tr)
{
	final = 0;
	etat_trans[ptr] = tr;
}

/*!
Transforme un état en un puits, c'est-à-dire un état dont n'importequelle lettre de l'alphabet définit une transition sur lui-même
\fn void etat::etat_puits()
\brief permet de créer un puits.
\deprecated
*/
void etat::etat_puits()
{
	final = 0;
	transitions tr;
	tr.transitions_puits();
	etat_trans[this]=tr;
}

/*!
Affichage d'un état
\fn void etat::affichage()
\brief affiche un état.
\deprecated
*/
void etat::affichage()
{
	for(std::map<etat*,transitions>::iterator it_etats = etat_trans.begin(); it_etats != etat_trans.end(); it_etats++ )
	{
		cout << "transitions vers l'état : " << it_etats->first << endl;
		etat_trans[it_etats->first].affichage();
	}
}

/*!
accesseur à la variable final
\fn bool etat::get_final()
*/
bool etat::get_final()
{
	return final;
}

/*!
accesseur à la transition vers l'état et pour le caractère de code ascii i
\fn bool etat::get_trans(etat* et, unsigned char i)
\param etat* et, unsigned char i
*/
bool etat::get_trans(etat* et, unsigned char i)
{
	return (etat_trans[et]).get_trans(i);
}

/*!
accesseur à la transition vers l'état et
\fn transitions etat::get_trans(etat* et)
\param etat* et
*/
transitions etat::get_trans(etat* et)
{
	return (etat_trans[et]);
}

/*!
accesseur à la variable etat_trans
\fn std::map<etat*,transitions> etat::get_etat_trans()
*/
std::map<etat*,transitions> etat::get_etat_trans()
{
	return etat_trans;
}

/*!
accesseur au booléen décrivant s'il existe une epsilon-transition jusqu'à l'état et
\fn bool etat::get_epsilon(etat* et)
\param etat* et
*/
bool etat::get_epsilon(etat* et)
{
	return (etat_trans[et]).get_epsilon();
}

/*!
mutateur de la variable final
\fn void etat::set_final(int val)
\param int val
*/
void etat::set_final(int val)
{
	final=val;
}

/*!
mutateur de la transition vers l'état et pour le caractère de code ascii i
\fn void etat::set_transition(etat* et, unsigned char i, bool val)
\param etat* et, unsigned char i, bool val
*/
void etat::set_transition(etat* et, unsigned char i, bool val)
{
	(etat_trans[et]).set_trans(i,val);
}

/*!
mutateur des transitions vers l'état et
\fn void etat::set_transitions(etat* et, transitions trans)
\param etat* et, transitions trans
*/
void etat::set_transitions(etat* et, transitions trans)
{
	etat_trans[et]=trans;
}

/*!
mutateur du booléen décrivant s'il existe une epsilon-transition jusqu'à l'état et
\fn void etat::set_epsilon(etat* et, bool epsilon)
\param etat* et, bool epsilon
*/
void etat::set_epsilon(etat* et, bool epsilon)
{
	(etat_trans[et]).set_epsilon(epsilon);
}
